const express = require('express');
const { Op } = require('sequelize');
const { body, query, param, validationResult } = require('express-validator');
const db = require('../models');
const logger = require('../utils/logger');

// 在文件开头添加模型检查
console.log('Category 模型:', db.Category);
console.log('Category 是否为函数:', typeof db.Category);
console.log('db 对象:', Object.keys(db));

const router = express.Router();
const { Category, Lesson } = db;

// ==================== 公共中间件 ====================

/**
 * 验证请求参数的中间件
 * 检查 express-validator 的验证结果，如果有错误则返回400状态码
 */
const handleValidation = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      error: '请求参数验证失败',
      details: errors.array()
    });
  }
  next();
};

// ==================== 查询功能 ====================

/**
 * 获取分类列表（支持分页、筛选、搜索）
 * GET /categories
 * 查询参数：
 * - page: 页码（可选，默认1）
 * - limit: 每页数量（可选，默认20，最大100）
 * - parentId: 父分类ID（可选，null表示顶级分类）
 * - isActive: 是否激活（可选，布尔值）
 * - search: 搜索关键词（可选，搜索名称和描述）
 */
router.get('/', [
  // 参数验证规则
  query('page').optional().isInt({ min: 1 }).withMessage('页码必须是正整数'),
  query('limit').optional().isInt({ min: 1, max: 100 }).withMessage('每页数量必须在1-100之间'),
  query('parentId').optional().isInt().withMessage('父分类ID必须是整数'),
  query('isActive').optional().isBoolean().withMessage('激活状态必须是布尔值'),
  query('search').optional().isLength({ min: 1 }).withMessage('搜索关键词不能为空'),
  handleValidation
], async (req, res) => {
  try {
    // 测试数据库连接
    await db.sequelize.authenticate();
    console.log('数据库连接正常');
    
    // 使用原生SQL查询检查所有表
    const [tables] = await db.sequelize.query("SHOW TABLES");
    console.log('数据库中的所有表:', tables);
    
    // 尝试查询可能的表名
    const possibleTableNames = ['categories', 'Categories', 'category', 'Category'];
    
    for (const tableName of possibleTableNames) {
      try {
        const [results] = await db.sequelize.query(`SELECT COUNT(*) as count FROM \`${tableName}\``);
        console.log(`表 ${tableName} 中的记录数:`, results[0].count);
      } catch (error) {
        console.log(`表 ${tableName} 不存在或查询失败`);
      }
    }
    
    // 添加更详细的调试信息
    console.log('请求查询参数:', req.query);
    
    // 先检查数据库中的所有分类
    const allCategories = await Category.findAll({
      attributes: ['id', 'name', 'isActive', 'parentId'],
      limit: 5 // 只查看前5条
    });
    console.log('数据库中前5条分类数据:', JSON.stringify(allCategories, null, 2));
    
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 20;
    const offset = (page - 1) * limit;
    
    console.log('分页参数 - page:', page, 'limit:', limit, 'offset:', offset);

    // 临时注释掉所有筛选条件
    const where = {};
    
    console.log('查询条件:', where);

    // 执行查询前先检查总数
    const totalCount = await Category.count({ where });
    console.log('符合条件的总记录数:', totalCount);

    const { count, rows } = await Category.findAndCountAll({
      where,
      // 临时简化查询，不包含关联数据
      order: [['id', 'ASC']],
      limit,
      offset,
      distinct: true
    });

    console.log('findAndCountAll 结果 - 总数:', count, '当前页数据条数:', rows.length);
    console.log('返回的数据ID列表:', rows.map(row => row.id));

    const result = {
      data:{
        data: rows,
        pagination: {
          page,
          limit,
          total: count,
          pages: Math.ceil(count / limit)
        }
    }
    };
    
    console.log('即将返回的响应结构:', {
      dataCount: result.data.length,
      pagination: result.pagination
    });

    res.json(result);

    logger.info(`获取分类列表完成 - 总数: ${count}, 当前页: ${rows.length}`);

  } catch (error) {
    logger.error('获取分类列表失败:', error);
    console.error('详细错误:', error);
    res.status(500).json({ error: '获取分类列表失败' });
  }
});

/**
 * 获取分类树结构
 * GET /categories/tree
 * 返回层级结构的分类数据，仅包含激活的分类
 */
router.get('/tree', async (req, res) => {
  try {
    // 查询所有顶级分类及其子分类
    const categories = await Category.findAll({
      where: { 
        isActive: true,
        parentId: null // 仅查询顶级分类
      },
      include: [
        {
          model: Category,
          as: 'children',
          where: { isActive: true },
          required: false,
          order: [['sortOrder', 'ASC'], ['name', 'ASC']]
        }
      ],
      order: [['sortOrder', 'ASC'], ['name', 'ASC']]
    });

    res.json({ data: categories });

  } catch (error) {
    logger.error('获取分类树失败:', error);
    res.status(500).json({ error: '获取分类树失败' });
  }
});

/**
 * 根据slug获取分类详情
 * GET /categories/slug/:slug
 * 通过分类标识符获取分类信息，适用于SEO友好的URL
 */
router.get('/slug/:slug', [
  param('slug').isLength({ min: 1 }).withMessage('分类标识不能为空'),
  handleValidation
], async (req, res) => {
  try {
    const category = await Category.findOne({
      where: { slug: req.params.slug },
      include: [
        {
          model: Category,
          as: 'parent',
          attributes: ['id', 'name', 'slug']
        },
        {
          model: Category,
          as: 'children',
          attributes: ['id', 'name', 'slug', 'icon', 'color', 'sortOrder'],
          where: { isActive: true },
          required: false,
          order: [['sortOrder', 'ASC'], ['name', 'ASC']]
        },
        {
          model: Lesson,
          as: 'lessons',
          attributes: ['id', 'title', 'slug', 'excerpt', 'difficulty', 'duration', 'isPublished'],
          where: { isPublished: true },
          required: false,
          order: [['sortOrder', 'ASC'], ['createdAt', 'DESC']]
        }
      ]
    });

    if (!category) {
      return res.status(404).json({ error: '分类不存在' });
    }

    res.json({ data: category });

  } catch (error) {
    logger.error('获取分类详情失败:', error);
    res.status(500).json({ error: '获取分类详情失败' });
  }
});

/**
 * 根据ID获取分类详情
 * GET /categories/:id
 * 返回完整的分类信息，包括父分类、子分类和关联课程
 */
router.get('/:id', [
  param('id').isInt().withMessage('分类ID必须是整数'),
  handleValidation
], async (req, res) => {
  try {
    const category = await Category.findByPk(req.params.id, {
      include: [
        {
          model: Category,
          as: 'parent',
          attributes: ['id', 'name', 'slug']
        },
        {
          model: Category,
          as: 'children',
          attributes: ['id', 'name', 'slug', 'icon', 'color', 'sortOrder'],
          where: { isActive: true },
          required: false,
          order: [['sortOrder', 'ASC'], ['name', 'ASC']]
        },
        {
          model: Lesson,
          as: 'lessons',
          attributes: ['id', 'title', 'slug', 'excerpt', 'difficulty', 'duration', 'isPublished'],
          where: { isPublished: true },
          required: false,
          order: [['sortOrder', 'ASC'], ['createdAt', 'DESC']]
        }
      ]
    });

    if (!category) {
      return res.status(404).json({ error: '分类不存在' });
    }

    res.json({ data: category });

  } catch (error) {
    logger.error('获取分类详情失败:', error);
    res.status(500).json({ error: '获取分类详情失败' });
  }
});

// ==================== 创建功能 ====================

/**
 * 创建新分类
 * POST /categories
 * 请求体参数：
 * - name: 分类名称（必填）
 * - slug: 分类标识符（必填，用于URL）
 * - description: 分类描述（可选，最多1000字符）
 * - icon: 图标名称（可选，最多100字符）
 * - color: 分类颜色（可选，十六进制格式 #RRGGBB）
 * - sortOrder: 排序权重（可选，整数）
 * - parentId: 父分类ID（可选，用于创建子分类）
 * - isActive: 是否激活（可选，布尔值，默认true）
 */
router.post('/', [
  // 验证必填字段
  body('name').notEmpty().withMessage('分类名称不能为空'),
  body('slug').notEmpty().withMessage('分类标识不能为空'),
  
  // 验证可选字段
  body('description').optional().isLength({ max: 1000 }).withMessage('描述不能超过1000字符'),
  body('icon').optional().isLength({ max: 100 }).withMessage('图标名称不能超过100字符'),
  body('color').optional().matches(/^#[0-9A-Fa-f]{6}$/).withMessage('颜色格式不正确'),
  body('sortOrder').optional().isInt().withMessage('排序权重必须是整数'),
  body('parentId').optional().isInt().withMessage('父分类ID必须是整数'),
  body('isActive').optional().isBoolean().withMessage('激活状态必须是布尔值'),
  
  handleValidation
], async (req, res) => {
  try {
    // 创建新分类
    const category = await Category.create(req.body);
    
    // 记录操作日志
    logger.info(`创建分类成功: ${category.name} (ID: ${category.id})`);
    
    res.status(201).json({
      message: '分类创建成功',
      data: category
    });

  } catch (error) {
    logger.error('创建分类失败:', error);
    
    // 处理唯一约束错误
    if (error.name === 'SequelizeUniqueConstraintError') {
      return res.status(409).json({ error: '分类名称或标识已存在' });
    }
    
    res.status(500).json({ error: '创建分类失败' });
  }
});

// ==================== 修改功能 ====================

/**
 * 更新分类信息
 * PUT /categories/:id
 * 支持部分更新，只更新提供的字段
 */
router.put('/:id', [
  // 验证路径参数
  param('id').isInt().withMessage('分类ID必须是整数'),
  
  // 验证请求体参数（所有字段都是可选的）
  body('name').optional().notEmpty().withMessage('分类名称不能为空'),
  body('slug').optional().notEmpty().withMessage('分类标识不能为空'),
  body('description').optional().isLength({ max: 1000 }).withMessage('描述不能超过1000字符'),
  body('icon').optional().isLength({ max: 100 }).withMessage('图标名称不能超过100字符'),
  body('color').optional().matches(/^#[0-9A-Fa-f]{6}$/).withMessage('颜色格式不正确'),
  body('sortOrder').optional().isInt().withMessage('排序权重必须是整数'),
  body('parentId').optional().isInt().withMessage('父分类ID必须是整数'),
  body('isActive').optional().isBoolean().withMessage('激活状态必须是布尔值'),
  
  handleValidation
], async (req, res) => {
  try {
    // 查找要更新的分类
    const category = await Category.findByPk(req.params.id);
    
    if (!category) {
      logger.info(`更新分类失败: 分类不存在`);
      return res.status(404).json({ error: '分类不存在' });
    }

    // 更新分类信息
    await category.update(req.body);
    
    // 记录操作日志
    logger.info(`更新分类成功: ${category.name} (ID: ${category.id})`);
    
    res.json({
      message: '分类更新成功',
      data: category
    });

  } catch (error) {
    logger.error('更新分类失败:', error);
    
    // 处理唯一约束错误
    if (error.name === 'SequelizeUniqueConstraintError') {
      return res.status(409).json({ error: '分类名称或标识已存在' });
    }
    
    res.status(500).json({ error: '更新分类失败' });
  }
});

// ==================== 删除功能 ====================

/**
 * 删除分类
 * DELETE /categories/:id
 * 删除前会检查：
 * 1. 是否存在子分类（递归检查）
 * 2. 是否有关联的课程
 * 只有通过所有检查才能删除
 */
router.delete('/:id', [
  param('id').isInt().withMessage('分类ID必须是整数'),
  handleValidation
], async (req, res) => {
  try {
    // 查找要删除的分类
    const category = await Category.findByPk(req.params.id);
    
    if (!category) {
      return res.status(404).json({ error: '分类不存在' });
    }

    /**
     * 递归检查所有子分类
     * @param {number} parentId - 父分类ID
     * @returns {Array} 所有子分类的数组
     */
    async function checkChildrenRecursively(parentId) {
      const children = await Category.findAll({
        where: { parentId: parentId },
        attributes: ['id', 'name']
      });
      
      if (children.length === 0) {
        return [];
      }
      
      // 递归检查每个子分类的子分类
      let allDescendants = [...children];
      for (const child of children) {
        const grandChildren = await checkChildrenRecursively(child.id);
        allDescendants = [...allDescendants, ...grandChildren];
      }
      
      return allDescendants;
    }

    // 检查是否有子分类（递归检查所有后代分类）
    const allChildren = await checkChildrenRecursively(req.params.id);
    
    if (allChildren.length > 0) {
      return res.status(400).json({ 
        error: '存在子分类，无法删除',
        children: allChildren.map(child => ({ id: child.id, name: child.name }))
      });
    }

    // 检查是否有关联的课程
    const lessonCount = await Lesson.count({
      where: { categoryId: req.params.id }
    });
    
    if (lessonCount > 0) {
      return res.status(400).json({ 
        error: `存在 ${lessonCount} 个关联的课程，无法删除` 
      });
    }

    // 执行删除操作
    await category.destroy();
    
    // 记录操作日志
    logger.info(`删除分类成功: ${category.name} (ID: ${category.id})`);
    
    res.json({ message: '分类删除成功' });

  } catch (error) {
    logger.error('删除分类失败:', error);
    res.status(500).json({ error: '删除分类失败' });
  }
});

module.exports = router; 